//******以下是全局参数区域****
//是否打开了表格编辑器
openTabelEdite=0
// 是否显示代码
showFlag=1
//剪贴板
cpb=""
//是否允许英文输入。默认0是英文开始输入。
englishflag=0
//显示源码
showCodeFlag=0
//格式刷动作
brushFlag=0
// 存储格式刷格式数据
format=
{
}
//这里设定上传文件大小（兆），同时也要在php init 中修改
var setSize=2048
//******以上是全局参数区域****

window.onload=function()
{
    //设置顶部的工具自动居中
    setMinMax()
    // 撤销和反撤销：在加载函数中调用了一次，里面定义了一个input触发函数
    // 如果这里调用又定义了一个input函数，到时输入时触发两个函数
    undoAandRundo()
    //文字加粗
    bold()
    //斜体字
    italic()
    // 下划线
    underline()
    //删除线
    strikethrough()
    //添加日期
    calendar()
    //左对齐
    left()
    //居中
    center()
    //右对齐
    right()
    // 两端对齐
    justify()
    //复制
    copy()
    //剪贴
    cut()
    //张贴
    paste()
    //解决键盘复制不能添加到自己剪贴板问题
    cv()
    //字体大小选项
    selectFontSize()
    //增减字号
    addAndsub()
    // 文件上传
    showUpFile()
    //刷新编辑按钮和分类框的初始化布局
    setMinMax()
    //选择标题
    showH()
    //背景色
    Abackground()
    // 字体颜色
    AColor()
    //显示或关闭源码
    showOrCloseCode()
    //格式刷
    brush()
    //清除格式
    eraser()
    //表格
    allTableFunction()
    //保存
    saveData()
    //编辑加载
    loadText()
    //获取字体表
    setFont()
    //给表格添加点击
    addClick()
    // 移动
    move()
    //标注*
    addDiagonal()
    //dimension()
    //鼠标移动工具栏
    toolMove()
    // table空格键
    table()
    // 解决表格张贴会带格式的问题
    // paseText()已经在加载函数中调用了一次所以不要调用
    //拖拉文件直接到编辑框进行上传
    dragImage()
}
//设置顶部的工具自动居中
window.addEventListener('resize',setMinMax);

function  setMinMax()
{
    var box=document.getElementById("box")
    var minMax=document.getElementById("minMax")
    var chld=document.getElementsByClassName("edit")[0]
    var upf=document.getElementById("showFile")
    box.style.width=document.getElementsByTagName("body")[0].offsetWidth*0.8+"px"
    var showStates=document.getElementById("showStates")
    var state=document.getElementById("state")
    var iconBox=document.getElementById("iconBox")
    var minMax=document.getElementById("minMax")
    var windowWidth = document.documentElement.clientWidth || window.innerWidth;
    upf.style.left=(box.offsetWidth-upf.offsetWidth)/2
    showStates.style.left=(windowWidth-150)/2+"px"
    if(iconBox.style.position!="fixed")
    {
        iconBox.style.width=document.getElementById("state").style.width
    }
    else
    {
        iconBox.style.width=document.getElementById("box").offsetWidth+"px"
        upf.style.left=(document.getElementsByTagName("body")[0].offsetWidth)/3.2+"px"
    }
    if(document.getElementsByClassName("fa").length*50<iconBox.offsetWidth)
    {
        minMax.style.height="40px"
    }
    else
    {
        minMax.style.height="82px"
    }
    oldW=box.offsetWidth
    childL=minMax.children.length
    childW=chld.offsetWidth
    if(oldW>childL*childW)
    {
        minMax.style.width=childL*childW+"px"
    }
    else
    {
        newW=Math.floor(oldW/50)*50
        minMax.style.width=newW+"px"
    }
    state.style.paddingLeft=(box.offsetWidth-minMax.offsetWidth)/2+"px"
}


/************************************以下是旧的撤销和返回功能******************/
// //撤销和反撤销
// let historyStack=[];
// let deleStack = [];
// function  undoAandRundo()
// {
//     //这里记录每次输入的内容，以便以通过弹出最后一个元素给deleStack
//     // 记录弹出的元素，获取第倒数二个元素来进行回退。
//     var hisL=20
//     historyStack.push(document.getElementById("text").innerHTML)
//     if(historyStack.length>hisL)
//     {
//         historyStack.shift()
//     }
//     if(deleStack.length>hisL)
//     {
//         deleStack.shift()
//     }
//     // console.log(historyStack)
//     // 这里记录historyStack弹出的最后一个元素，以便弹出自己最后一个给historyStack
//     // 进行前进
//     const editableDiv = document.getElementById('text');
//     // *************解决中文输入或英文输入问题************
//     // 1、同一个元素的监听是重写js类中的行数，行数的执行顺序在js类中默认已经
//     // 写死了，所以，这里的重写不改变监听的顺序。
//     // 这里先触发compositionstart，然后是 input 然后是compositionend
//     // 这里必须有个标记，标记是中文输入开始了，还是英文输入开始了
//     //compositionstart 中文开始输入就会触发一次，后面不会再触发。
//     // 触发中文输入了说明后面的都是中文，直到出现compositionend
//     // 表示中文输入结束。后面再输入才会再次触发compositionstart

//     editableDiv.addEventListener('compositionstart', function(event)
//     {
//         // 这里表示已经触发了中文输入后面的都是中文输入，
//         // 所以英文输入标志变为1，掐断后面的input监听（所有的输入类型）
//         //解决按一次触发两次问题
//         if(showFlag==1)
//         {
//             console.log("\n#####中文输入开始:");
//         }
//         englishflag=1;
//     }
//     );
//     // compositionend这里表示中文输入完成了，然后获取文本框中文本放在数组中，
//     // 中文输入完成后打开掐断英文输入的标致，说明英文可以输入了。用于是input先
//     // 执行所以这时英文在掐断状态，所以input监听中不能获取数据，修改列表。

//     // 所以在最后也是在compositionend中要执行获取数据和修改列表行为。
//     editableDiv.addEventListener('compositionend', function(event)
//     {
//         const text = editableDiv.innerHTML;
//         historyStack.push(text);
//         englishflag=0;
//         if(historyStack.length>hisL)
//         {
//             historyStack.shift()
//         }
//         if(deleStack.length>hisL)
//         {
//             deleStack.shift()
//         }
//         if(showFlag==1)
//         {
//             console.log("  记录栈:",historyStack);
//             console.log("  删除栈:",deleStack);
//             console.log("#####中文输入结束,恢复英文输入");
//         }
//     }
//     );
//     // 这里是英文输入监听input，当进入中文输入时掐断判断为1，所以不能
//     // 获取英文数据和修改列表，当中文输入完成，由于input先执行所以英文
//     // 还是不能输入，等中文输入完成之后compositionend恢复英文输入，flage=0
//     // 所以如果这是输入法切换到英文了就不会掐断，可以进行英文输入了。

//     editableDiv.addEventListener('input', function(event)
//     {
       
//         var  text = editableDiv.innerHTML;
//         if(showCodeFlag!=1)
//         {
//             var cn=editableDiv.childNodes
//             var len=cn.length
//             for(var i=0;i<len;i++)
//             {
//                 if(cn[i] instanceof Text)
//                 {
//                     var p=document.createElement("p")
//                     p.innerHTML=cn[i].nodeValue+"<br>"
//                     editableDiv.insertBefore(p,cn[i])
//                     editableDiv.removeChild(cn[i+1])
//                 }
//                 //由于规定编辑框中要为p的独立块，其中在记录函数中
//                 //有这项检查，所以必须包装为p
//                 else if(cn[i]!=undefined&&cn[i].tagName!="P")
//                 {
//                     var p=document.createElement("p")
//                     p.innerHTML=cn[i].innerHTML+" "
//                     editableDiv.insertBefore(p,cn[i])
//                     editableDiv.removeChild(cn[i+1])
//                 }
//                 else if(cn[i]!=undefined&&cn[i].innerText.replace(/\s+/ig,"").length==0&&cn[i].getElementsByTagName("table")==null&&cn[i].getElementsByTagName("img")==null)
//                 {
//                     cn[i].innerHTML="<br>"
//                 }
//                 if(i==(len-1)&&cn[i]!=undefined&&cn[i].innerHTML.replace(/\s+/ig,"")!="<br>")
//                 {
//                     var pbr=document.createElement("p")
//                     pbr.innerHTML="<br>"
//                     editableDiv.appendChild(pbr)
//                 }
//             }
//             if (len==0)
//             {
//                 editableDiv.innerHTML="<p><br></p>"
//             }
//         }



//         if(englishflag==0)
//         {
//             if(historyStack.length>hisL)
//             {
//                 historyStack.shift()
//             }
//             if(deleStack.length>hisL)
//             {
//                 deleStack.shift()
//             }
//             historyStack.push(text);
//             if(showFlag==1)
//             {
//                 console.log("\n******英文输入:")
//                 console.log("  记录栈:",historyStack)
//                 console.log("  删除栈:",deleStack)
//                 console.log("******英文结束:")
//             }
//         }
//     }
//     );

//     // 这里是撤销操作
//     function undo()
//     {
//         if (historyStack.length == 0) return;
//         //记录栈弹出最后输入的数据到删除栈中，然后把记录栈倒数第二个
//         // 放到文本中。
//         if(historyStack.length>1)
//         {
//             var getText=historyStack.pop()
//             deleStack.push(getText);
//             const text = historyStack[historyStack.length - 1];
//             editableDiv.innerHTML = text || '';
//         }
//         else
//         {
//             const text = historyStack[historyStack.length - 1];
//             editableDiv.innerHTML = text || '';
//         }
//         if(showFlag==1)
//         {
//             console.log("撤销#")
//             console.log("  记录栈:",historyStack)
//             console.log("  删除栈:",deleStack)
//         }
//     }

//     // 实现反撤销功能
//     function reundo()
//     {
//         // 如果删除栈中有数据进行反撤销，没有就结束
//         if (deleStack.length ===0) return;
//         var ctext=editableDiv.innerHTML
//         //删除栈通过弹出的形式给记录栈恢复数据。
//         var getText=deleStack.pop()
//         historyStack.push(getText);
//         // 然后把记录栈最后的数据给文本框中
//         const text = deleStack[deleStack.length - 1];
//         editableDiv.innerHTML= historyStack[historyStack.length-1];
//         if(showFlag==1)
//         {
//             console.log("反撤销#")
//             console.log("记录栈:",historyStack)
//             console.log("删除栈:",deleStack)
//         }
//     }

//     document.getElementById("undo").onclick=function()
//     {
//         undo()
//     }

//     document.getElementById("reundo").onclick=function()
//     {
//         reundo()
//     }
// }

/**************************以上是旧的撤销返回功能实现************/


/**************************以下是新的撤销返回功能实现************/


//历史日志，便于撤销
var  historyStack=[];
//接收删除的历史日志，便于返回
var  deleStack = [];
var tlen=0
//光标位置记录
var positionH="noPosition"
//原始文本，便于和修改后的文本比较
var oldT=""
var editableDiv=document.getElementById('text')

var positionH=[]


/******下面是解决框选点击其它位置光标不回位的位置******/
var kendContainer=""
var kendOffset=0
/******上面是解决框选点击其它位置光标不回位的位置******/
//解决点击和输入同时进行问题
var clickFlag=0
//这里解决输入和点击同时进行出现错误
//正常操作是先点击获取位置信息后再进
//行输入

function stopDefault(e)
{
   
    e.preventDefault()
}
editableDiv.addEventListener("mousedown",
    function()
    {
        editableDiv.addEventListener("keydown",stopDefault)

    })



editableDiv.addEventListener("mouseup",
    function()
    {
       
       

        //这里解决输入和点击同时进行出现错误
        //正常操作是先点击获取位置信息后再进
        //行输入
        /*******************以下是处理鼠标点击和输入同时进行的新方法********/
        //这里要先获得焦点，
        //如果编辑框都没有焦点则不能
        //获得位置
        positionH=getPositon(editableDiv)
        //原始文本，便于和修改后的文本比较
        oldT=editableDiv.innerHTML
      
        /*******************以下是处理鼠标点击和输入同时进行的旧方法********/
         // setTimeout(function(){
         //     editableDiv.contentEditable=true
         //     var br=oldT.substring(positionH[0],positionH[1])
         //     editableDiv.focus()
         //     clickFlag=1
         // /*****以下是处理框选后点击其它区域出现问题****************/
         //     //下面是解决框选后再次点击其它位置光标是否回到开始位置。
         //     //是通过光标回到了开始位置判断框选后点击出现问题。
         //     //就通过移动光标来回到想要的位置。
         //     //如果点击的是0位置，下面的也成立。
         //     var selection=document.getSelection()
         //     var range=selection.getRangeAt(0)
         //     var endContainer=range.endContainer
         //     var endOffset=range.endOffset
         //     if(endOffset==0&&kendContainer.length!=0)
         //     {
         //         range=document.createRange()
         //         range.setStart(kendContainer,kendOffset)
         //         range.collapse(true)
         //         selection.removeAllRanges()
         //         selection.addRange(range)
         //     }
         //     kendContainer=endContainer
         //     kendOffset=endOffset
         // /*****以上是处理框选后点击其它区域出现问题****************/
         // },100)
    /*******************以上是处理鼠标点击和输入同时进行的旧方法********/
   
        setTimeout(function(){
            editableDiv.removeEventListener("keydown",stopDefault)
        },100)

    })



//如果文本框变动就进行历史记录
function ip(g)
{
    //这里要获取原始文本长度，这样
    //便于与后面变动的文本进行比较
    //由于每次只有一次点击更新原始
    //文本信息所以后面要更新为变动后的信息
    tlen=oldT.length

    //每次变动就进行历史记录
    addLog(editableDiv)
    //解决文本末尾没有<p><br></p>问题
    //这里必须用appendChild,不能用innerHTMl
    //他会改变光标位置。
    var ch=editableDiv.childNodes
    var clen=ch.length
    var p=document.createElement("p")
    var br=document.createElement("br")
    p.appendChild(br)
    if(clen==0||ch[clen-1].innerHTML!="<br>")
    {
        editableDiv.appendChild(p)
    }
    //因为第一次框选后导致position
    //不同，所以再输入时要更新位置
    positionH=getPositon(g)
    oldT=g.innerHTML

}


//历史记录函数
function addLog(g)
{
    //这里获得变动的文本
    var text=g.innerHTML
    //获得变动文本的长度
    var cLen=text.length
    //看变动文本和原来的比较是否变长了
    var subL=cLen-tlen
    //这里判断光标是否获得，没有获得就不执行下面的
    if (positionH!="noPosition")
    {
        //光标开始位置
        var start=positionH[0]
        //光标结束位置
        var end=positionH[1]
        //如果变动的文本比原来的长就进行了添加操作
        if(cLen>tlen)
        {
            //如果光标的位置开始和结束位置一样说明只是添加
            if(start==end)
            {  
                //解决不框选，之间删除一个字符导致<br>自动恢复的问题
                var br=text.substring(start-1,start+3)
                if(br=="<br>")
                {
                    historyStack.push([start-1,oldT.substring(start-1,end),subL,"changeAdd","<br>"])
                }
                else
                {
                    historyStack.push([start-1,"",subL,"add",text.substring(start,start+subL)])
                }
            }
            //如果光标的位置开始和结束位不一样
            //说明只是把某个字符修改了并变长了
            else if(start!=end)
            {   
                historyStack.push([start,oldT.substring(start,end),subL,"changeAdd",text.substring(start,end+subL)])
            }
            len=cLen 
        }
        //如果变动的文本比原来的短了就进行了删除操作
        else if(cLen<tlen)
        {
            //如果光标的位置开始和结束位置一样说明只是删除
            if(start==end)
            {   
                historyStack.push([start-2,oldT.substring(start-subL-1,end-1),subL,"dele"])
            }
            //如果光标的位置开始和结束位不一样
            //说明只是把某个字符修改了并变短了了
            else if(start!=end)
            {   
                //如果开始和结束位置的差等于文本差说明是框选删除
                if((start-end)==subL)
                {
                    historyStack.push([start-1,oldT.substring(start,end),subL,"selectionDele",""])
                }
                //如果不是始和结束位置的差等于文本差说明是修改删除
                else
                {
                    historyStack.push([start-1,oldT.substring(start,end),subL,"changeDele",text.substring(start,end+subL)])
                }
            }
            tlen=cLen
        }
        //如果原来的和现在的长度一样说明只是某个修改
        else if(cLen==tlen)
        {
            historyStack.push([start-1,oldT.substring(start,end),subL,"change",text.substring(start,end)])
        }
    }
     oldT=g.innerHTML
}


//获取光标组合位置
function getPositon(text)
{
    var start=0
    var end=0
    var sf=0
    var ef=0
    const selection = document.getSelection();
    if (selection.rangeCount > 0)
    {
        const range = selection.getRangeAt(0);
        const startContainer = range.startContainer;
        const startOffset =range.startOffset;
        const endContainer =range.endContainer;
        const endOffset = range.endOffset;
        toCh(text,startContainer,endContainer,startOffset,endOffset)
        start+=startOffset
        end+=endOffset
        return [start,end]
    }
    else
    {
        return "noPosition"
    }

    function toCh(p,sc,ec,s,e,g=0,h=0)
    {
        var sc=sc
        var ec=ec
        var ch=p.childNodes
        for(var i=0;i<ch.length;i++)
        {
            //这里获取开始位置
            if(sf==0&&g==0)
            {
                if(!ch[i].contains(sc))
                {
                    if(ch[i].nodeType!=3)
                    {
                    start+=ch[i].outerHTML.length
                    }
                    else
                    {
                    start+=ch[i].textContent.length
                    }
                }
                else
                {
                    if(ch[i].nodeType!=3)
                    {
                        var gh=ch[i].innerHTML
                        var ko=sc.textContent
                        if(gh!=ko&&ch[i]!=sc)
                        {
                              var outer=ch[i].outerHTML
                              var inner=ch[i].innerHTML
                              var r=outer.replace(inner,"").replace(/<\/[a-zA-Z]+>/ig,"")
                              start+=r.length
                            toCh(ch[i],sc,ec,s,e,0,1)
                        }
                        else if(gh==ko||ch[i]==sc)
                        {
                            sf=1
                            var outer=ch[i].outerHTML
                            var inner=ch[i].innerHTML
                            var r=outer.replace(inner,"").replace(/<\/[a-zA-Z]+>/ig,"")
                            start+=r.length
                        }
                    }
                    else
                    {
                        sf=1
                    }
                }
            }

            //这里是获取结束位置
            if(ef==0&&h==0)
            {
                if(!ch[i].contains(ec))
                {
                    if(ch[i].nodeType!=3)
                    {
                        end+=ch[i].outerHTML.length
                    }
                    else
                    {
                        end+=ch[i].textContent.length
                    }
                }
                else
                {
                    if(ch[i].nodeType!=3)
                    {
                        var gh=ch[i].innerHTML
                        var ko=ec.textContent
                        if(gh!=ko&&ch[i]!=ec)
                        {
                          var outer=ch[i].outerHTML
                          var inner=ch[i].innerHTML
                          var r=outer.replace(inner,"").replace(/<\/[a-zA-Z]+>/ig,"")
                          end+=r.length
                          toCh(ch[i],sc,ec,s,e,1,0)
                        }
                        //
                        //如果是<p>fdsf</p>这时开始容器是fdsf，
                        //是文本类型，如果<p><br></p>，这里开始
                        //容器是<p><br></p>。这里解决<p>fdsf
                        //</p>问题
                        else if(gh==ko)
                        {
                          ef=1
                          var outer=ch[i].outerHTML
                          var inner=ch[i].innerHTML
                          var r=outer.replace(inner,"").replace(/<\/[a-zA-Z]+>/ig,"")
                          end+=r.length
                        }
                        //这里解决<p><br></p>问题
                        else if(ch[i]==ec)
                        {
                            ef=1
                            var outer=ch[i].outerHTML
                            var inner=ch[i].innerHTML
                            var r=outer.replace(inner,"").replace(/<\/[a-zA-Z]+>/ig,"")
                            end+=r.length+4
                        }
                    }
                    else
                    {
                        ef=1
                    }
                }
            }
        }
    }
}


//解析记录
function analysis(g,flag="log")
{
    var m=0
    var text=g.innerHTML
    //撤销输入
    if(flag=="log")
    {   
        if(historyStack.length>0)
        {
            //获得最近添加的记录
            var pre=historyStack.pop()
            //获取现在的文本，便于根据记录修改内容
            deleStack.push(pre)
            if(pre[3]=="add")
            {
                m=text.substring(0,pre[0]+1)+text.substring(pre[0]+pre[2]+1,text.length)
            }
            else if(pre[3]=="changeAdd")
            { 
                m=text.substring(0,pre[0])+pre[1]+text.substring(pre[0]+pre[1].length+pre[2],text.length)
            }
            else if(pre[3]=="dele")
            {
                m=text.substring(0,pre[0]+1)+pre[1]+text.substring(pre[0]+1,text.length)
            }
            else if(pre[3]=="selectionDele")
            {
                m=text.substring(0,pre[0]+1)+pre[1]+text.substring(pre[0]+1,text.length)
            }
            else if(pre[3]=="changeDele")
            {    
                m=text.substring(0,pre[0]+1)+pre[1]+text.substring(pre[0]+1+pre[4].length,text.length)
            }
            else if(pre[3]=="change")
            {
                console.log(pre)
                m=text.substring(0,pre[0]+1)+pre[1]+text.substring(pre[0]+1+pre[4].length,text.length)
            }
        } 
    }

    //运用输入
    else if(flag=="dLog")
    {
        if(deleStack.length>0)
        {
            var pre=deleStack.pop()
            historyStack.push(pre)
            //使用想要的增加
            if(pre[3]=="add")
            {
                m=text.substring(0,pre[0]+1)+pre[1]+pre[4]+text.substring(pre[0]+1,text.length)

            }
            //使用想要的修改增加
            else if(pre[3]=="changeAdd")
            {
                m=text.substring(0,pre[0])+pre[4]+text.substring(pre[0]+pre[1].length,text.length+1)
            }
            //使用想要的删除
            else if(pre[3]=="dele")
            {  
                m=text.substring(0,pre[0]+1)+text.substring(pre[0]+1+pre[1].length,text.length)
            }
            //使用框选删除
            else if(pre[3]=="selectionDele")
            {
                m=text.substring(0,pre[0]+1)+pre[4]+text.substring(pre[0]+1+Math.abs(pre[2]),text.length)
            }
            //使用想要的删修改
            else if(pre[3]=="changeDele")
            {   
                m=text.substring(0,pre[0]+1)+pre[4]+text.substring(pre[0]+1+pre[1].length,text.length)

            }
            //使用想要的修改
            else if(pre[3]=="change")
            {
                m=text.substring(0,pre[0]+1)+pre[4]+text.substring(pre[0]+1+pre[4].length,text.length)
            }
        }
    }

    if(m==0)
    {
        return "fail"
    }
    return m
}


function  undoAandRundo()
{
    const editableDiv = document.getElementById('text');
    // *************解决中文输入或英文输入问题************
    // 1、同一个元素的监听是重写js类中的行数，行数的执行顺序在js类中默认已经
    // 写死了，所以，这里的重写不改变监听的顺序。
    // 这里先触发compositionstart，然后是 input 然后是compositionend
    // 这里必须有个标记，标记是中文输入开始了，还是英文输入开始了
    //compositionstart 中文开始输入就会触发一次，后面不会再触发。
    // 触发中文输入了说明后面的都是中文，直到出现compositionend
    // 表示中文输入结束。后面再输入才会再次触发compositionstart

    editableDiv.addEventListener('compositionstart', function(event)
    {
        // 这里表示已经触发了中文输入后面的都是中文输入，
        // 所以英文输入标志变为1，掐断后面的input监听（所有的输入类型）
        //解决按一次触发两次问题
        
         if(showFlag==1)
         {
             console.log("\n#####中文输入开始:");
         }
         englishflag=1;
        
    });

    // compositionend这里表示中文输入完成了，然后获取文本框中文本放在数组中，
    // 中文输入完成后打开掐断英文输入的标致，说明英文可以输入了。用于是input先
    // 执行所以这时英文在掐断状态，所以input监听中不能获取数据，修改列表。
    // 所以在最后也是在compositionend中要执行获取数据和修改列表行为。
    editableDiv.addEventListener('compositionend', function(event)
    {
        
         ip(editableDiv)
         englishflag=0;
         if(showFlag==1)
         {
            console.log("  记录栈:",historyStack);
            console.log("  删除栈:",deleStack);
            console.log("#####中文输入结束,恢复英文输入");
         }
    });

    // 这里是英文输入监听input，当进入中文输入时掐断判断为1，所以不能
    // 获取英文数据和修改列表，当中文输入完成，由于input先执行所以英文
    // 还是不能输入，等中文输入完成之后compositionend恢复英文输入，flage=0
    // 所以如果这是输入法切换到英文了就不会掐断，可以进行英文输入了。
    editableDiv.addEventListener('input', function(event)
    {
    
        if(englishflag==0)
        {   
            ip(editableDiv)
            if(showFlag==1)
            {
                console.log("\n******英文输入:")
                console.log("  记录栈:",historyStack)
                console.log("  删除栈:",deleStack)
                console.log("******英文结束:")
            }
        }
    });

    // 这里是撤销操作
    function undo()
    {  
        //避免有一个要走复杂程序的还没走完
        //新的程序就开始了，而新的程序
        //要在复杂程序基础上运行，且比较简单
        //这样会导致错误
        setTimeout(function()
        {
            var result=analysis(editableDiv)
            if(result!="fail")
            {
                editableDiv.innerHTML=result
            }
            else
            {
                console.log("undo()中出现失败")
                return
            }
            if(showFlag==1)
            {
                console.log("撤销#")
                console.log("  记录栈:",historyStack)
                console.log("  删除栈:",deleStack)
            }
        },100)
    }

    // 实现反撤销功能
    function reundo()
    {
        //避免有一个要走复杂程序的还没走完
        //新的程序就开始了，而新的程序
        //要在复杂程序基础上运行，且比较简单
        //这样会导致错误
        setTimeout(function()
        {
            var result=analysis(editableDiv,"dLog")
            if(result!="fail")
            {
                editableDiv.innerHTML=result
            }
            else
            {
                console.log("reundo()解析失败")
                return
            }
            if(showFlag==1)
            {
                console.log("反撤销#")
                console.log("记录栈:",historyStack)
                console.log("删除栈:",deleStack)
            }
        },100)
    }


    document.getElementById("undo").onclick=function()
    {
        setTimeout(function()
        {
            undo()
        },50)
        
       
    }

    document.getElementById("reundo").onclick=function()
    {
        setTimeout(function()
        {
            reundo()
        },50)
       
    }
}

/**************************以上是新的撤销返回功能实现************/













function  bold()
{
    var bd=document.getElementById("bold")
    var unbd=document.getElementById("unBold")

    bd.onclick=function()
    {
        if(showCodeFlag==1)
        {
            alert("目前为代码模式请先返回")
            return
        }
        $("#bold").selsectObj(
        {
            "style":"font-weight:bolder"
        }
        )
    }

    unbd.onclick=function()
    {
        if(showCodeFlag==1)
        {
            alert("目前为代码模式请先返回")
            return
        }
        $("#unBold").selsectObj(
        {
            "style":"font-weight:normal"
        }
        )
    }
}

//斜体字
function italic()
{
    var it=document.getElementById("italic")
    var unIt=document.getElementById("unItalic")

    it.onclick=function ()
    {
        if(showCodeFlag==1)
        {
            alert("目前为代码模式请先返回")
            return
        }
        $("#italic").selsectObj(
        {
            "style":"font-style:italic"
        }
        )
    }

    unIt.onclick=function()
    {
        if(showCodeFlag==1)
        {
            alert("目前为代码模式请先返回")
            return
        }
        $("#unItalic").selsectObj(
        {
            "style":"font-style:normal"
        }
        )
    }
}

// 下划线
function underline()
{
    var ud=document.getElementById("underline")
    var unUd=document.getElementById("unUnderline")

    ud.onclick=function ()
    {
        if(showCodeFlag==1)
        {
            alert("目前为代码模式请先返回")
            return
        }
        $("#italic").selsectObj(
        {
            "style":"text-decoration:underline+"
        }
        )
    }

    unUd.onclick=function()
    {
        if(showCodeFlag==1)
        {
            alert("目前为代码模式请先返回")
            return
        }
        $("#unItalic").selsectObj(
        {
            "style":"text-decoration:underline--"
        }
        )
    }
}

// 删除线
function strikethrough()
{
    var st=document.getElementById("strikethrough")
    var unSt=document.getElementById("unStrikethrough")

    st.onclick=function ()
    {
        if(showCodeFlag==1)
        {
            alert("目前为代码模式请先返回")
            return
        }
        $("#italic").selsectObj(
        {
            "style":"text-decoration:line-through+"
        }
        )
    }

    unSt.onclick=function()
    {
        if(showCodeFlag==1)
        {
            alert("目前为代码模式请先返回")
            return
        }
        $("#unItalic").selsectObj(
        {
            "style":"text-decoration:line-through--"
        }
        )
    }
}

//添加日期
function calendar()
{
    var ca=document.getElementById("calendar")

    ca.onclick=function()
    {
        if(showCodeFlag==1)
        {
            alert("目前为代码模式请先返回")
            return
        }
        const year = new Date().getFullYear();
        const month = new Date().getMonth() + 1; //getMonth()返回的是0-11，需要加1来表示实际的月份
        const day = new Date().getDate();
        const dd=new Date().getDay();
        const hours = new Date().getHours();
        const minutes = new Date().getMinutes();
        const seconds = new Date().getSeconds();
        getAtR(""+year+"年"+month+"月"+day+"日"+hours+"时"+minutes+"分"+seconds+"秒|星期"+(dd))
    }
}

//获取光标
function getLight()
{
    var selection=document.getSelection()
    var text=document.getElementById("text")
    if(selection.anchorNode!=null&&text.contains(selection.anchorNode))
    {
        text.removeEventListener("click",clickText)
        return selection.getRangeAt(0);
    }
    else
    {
        text.addEventListener("click",clickText)
        return "no"
    }
}

//和上面的函数一起解决表格插入不能聚焦问题
function clickText(e)
{
    lightMouse=document.getSelection().getRangeAt(0)
}

// 完结：获取i光标所在位置并插入内容
function   getAtR(content)
{
    if(getBrowser()=='ie')
    {
        o=document.selection.createRange();
        o.pasteHTML(content);
    }
    else if(getBrowser()=='chrome')
    {
        var rng = document.getSelection().getRangeAt(0);
        var frg = rng.createContextualFragment(content);
        rng.deleteContents()
        rng.insertNode(frg);
    }

    //获取浏览器版本
    function getBrowser()
    {
        var agentValue = window.navigator.userAgent.toLowerCase();
        if(agentValue.indexOf('msie')>0)
        {
            return "ie";
        }
        else if(agentValue.indexOf('firefox')>0)
        {
            return "ff";
        }
        else if(agentValue.indexOf('chrome')>0)
        {
            return "chrome";
        }
    }
}

//左对齐
function left()
{
    var lf=document.getElementById("left")

    lf.onclick=function()
    {
        if(showCodeFlag==1)
        {
            alert("目前为代码模式请先返回")
            return
        }
        if(jdS())
        {
            return
        }
        document.execCommand("JustifyLeft")
        editableDiv.focus()
        // 因为执行上面的命令时已经触发input函数导致记录了一次所以下面的不需要
        // undoAandRundo()
    }
}

// 居中
function center()
{
    var ct=document.getElementById("center")

    ct.onclick=function()
    {
        if(showCodeFlag==1)
        {
            alert("目前为代码模式请先返回")
            return
        }
        if(jdS())
        {
            return
        }
        document.execCommand("JustifyCenter")
        editableDiv.focus()
        // 因为执行上面的命令时已经触发input函数导致记录了一次所以下面的不需要
        // undoAandRundo()
    }
}

// 右对齐
function right()
{
    var rt=document.getElementById("right")

    rt.onclick=function()
    {
        if(showCodeFlag==1)
        {
            alert("目前为代码模式请先返回")
            return
        }
        if(jdS())
        {
            return
        }
        document.execCommand('justifyright')
        editableDiv.focus()
        // 因为执行上面的命令时已经触发input函数导致记录了一次所以下面的不需要
        // undoAandRundo()
    }
}

// 两端对齐
function justify()
{
    var jf=document.getElementById("justify")

    jf.onclick=function()
    {
        if(showCodeFlag==1)
        {
            alert("目前为代码模式请先返回")
            return
        }
        if(jdS())
        {
            return
        }
        document.execCommand('justifyfull')
        editableDiv.focus()
        // 因为执行上面的命令时已经触发input函数导致记录了一次所以下面的不需要
        // undoAandRundo()
    }
}

//复制
function  copy()
{
    var text=document.getElementById("text")
    var cp=document.getElementById("copy")

    cp.onclick=function()
    {
        if(jdS())
        {
            return
        }
        cpb=document.getSelection().toString()
        document.execCommand("copy")
        //复制不需要保存数据
        // undoAandRundo()
    }
}
//剪贴

function cut()
{
    var text=document.getElementById("text")
    var ct=document.getElementById("cut")

    //  ct.ontouchend=function()
    //
    {
        // cpb=document.getSelection().toString()
        //   document.execCommand("cut")
        //    undoAandRundo()
        //    // alert(90)
        //
    }

    ct.onclick=function()
    {
        if(jdS())
        {
            return
        }
        //解决剪贴变动了导致文本输入变化，导致历史记录把它记录了
        cpb=document.getSelection().toString()
        document.execCommand("cut")
    }
}

//张贴
function paste()
{
    var text=document.getElementById("text")
    var pt=document.getElementById("paste")

    pt.onclick=function()
    {
        if(jdS("请选择位置"))
        {
            return
        }
        getAtR(cpb)
        // undoAandRundo()
    }
}

// 解决键盘复制后没有把内容放在自己的剪贴板中的问题。
function cv()
{
    var text=document.getElementById('text')
    var flg=0
    var cf=0
    text.addEventListener("focus",function()
    {
        flg=1
    })
    text.addEventListener("blur",function()
    {
        flg=0
        cf=0
    })

    document.addEventListener("keydown",function(e)
    {


        if((e.ctrlKey && e.key=="c")||(e.key=="Meta" && e.key=="c")||(e.key="Control" && e.key=="c"))
        {

            //解决第一次复制问题
            if(flg==1)
            {
                cf=1
            }
            
            cpb=document.getSelection().toString()
        }

        if((e.ctrlKey && e.key=="x")||(e.key=="Meta" && e.key=="x")||(e.key="Control" && e.key=="x"))
        {   
            //解决第一次剪切问题
            if(flg==1)
            {
                cf=1
            }
            cpb=document.getSelection().toString()
        }
        if((e.ctrlKey && e.key=="v")||(e.key=="Meta" && e.key=="v")||(e.key="Control" && e.key=="v"))
        {   
            //这里解决原始的粘贴快捷键导致产生额外的span标签
            //但是复制没有重写，所以依然可以负责粘贴到外部文本
            if(cf==1&&flg==1)
            {
                e.preventDefault()
                getAtR(cpb)
                ip(text)
            }
        }
    })
}



async function writeToClipboard(text) {
    if (navigator.clipboard) {
        navigator.clipboard.writeText(text)
           .then(() => {
                console.log('文本已成功复制到剪贴板');
            })
           .catch((error) => {
                console.error('复制文本到剪贴板时出错:', error);
            });
    } else {
        console.error('当前浏览器不支持 Clipboard API');
    }
}


//字体大小选项
getSelection=""

function selectFontSize()
{
    var box=document.getElementById("showFontSize")
    var tt=document.getElementById("tt")
    var fontSizeYes=document.getElementById("fontSizeYes")
    var fontSizeNumber=document.getElementById("fontSizeNumber")

    tt.onclick=function()
    {
        if(showCodeFlag==1)
        {
            alert("目前为代码模式请先返回")
            return
        }
        closeIndex("showFontSize")
        if(box.style.display=="none")
        {
            box.style.display="inline-block"
            box.style.left=0+"px";
            box.style.top=40+"px"
            tt.style.color="blue"
        }
        else
        {
            box.style.display="none"
            t.style.color="black"
        }
    }

    fontSizeYes.onclick=function()
    {
        if(jdS("请框选文字"))
        {
            return
        }
        $().selsectObj(
        {
            "style":"font-size:"+fontSizeNumber.innerText
        }
        )
        box.style.display="none"
        // undoAandRundo()
    }
    var leng=10
    for(var i=0;i<leng;i++)
    {
        var el=document.createElement("span")
        el.innerHTML=10+(i+1)*2+"px"
        el.style.display="inline-block"
        el.style.width="100%"
        el.style.height="30px"
        el.style.borderBottom="1px solid #ccc"
        el.style.fontSize="12px"
        el.style.lineHeight=el.style.height

        el.onclick=function()
        {
            if(jdS())
            {
                return
            }
            $().selsectObj(
            {
                "style":"font-size:"+this.innerText
            }
            )
            box.style.display="none"
            editableDiv.focus()
            // undoAandRundo()
        }
        box.appendChild(el)
    }
}

//增减字号
function  addAndsub()
{
    var subNumber=document.getElementById("subNumber")
    var addNumber=document.getElementById("addNumber")
    var fontSizeNumber=document.getElementById("fontSizeNumber")

    addNumber.onclick=function()
    {
        var nb=parseInt(fontSizeNumber.innerText.replace("px",""))
        if(nb<100)
        {
            nb+=1
            fontSizeNumber.innerText=nb+"px"
        }
    }

    subNumber.onclick=function()
    {
        if(jdS())
        {
            return
        }
        var nb=parseInt(fontSizeNumber.innerText.replace("px",""))
        if(nb>1)
        {
            nb-=1
            fontSizeNumber.innerText=nb+"px"
        }
    }
}

//显示状态：
function state(t,flag="no")
{
    var st=document.getElementById("stateWorder")
    var showStates=document.getElementById("showStates")
    st.innerHTML="状态:"+t
    if(t.replace("状态:","").replace(/\s+/ig,"").length!=0)
    {
        showStates.innerText="状态:"+t
        showStates.style.display="block"
        if(flag!="no")
        {
            setTimeout(function()
            {
                showStates.style.display="none"
            },1500)
        }
    }
}

//上传
function showUpFile()
{
    //文件在哪处理
    var uploadUrl="dealCenter.php"
    // 指定文件存储路径
    var fileURL="/static/media/"
    var upFile=document.getElementById("file")
    var showFile=document.getElementById("showFile")
    var box=document.getElementById("box")
    var fileName=""
    var url =""
    var el=document.getElementById("preview")
    var oDataFlag=document.getElementById("oDataFlag")
    var uploadY=document.getElementById("uploadY")
    var uploadC=document.getElementById("uploadC")
    var upload=document.getElementById("upload")
    var preview=document.getElementById("preview")
    var selectFile=document.getElementById("selectFile")
    var file=""
    var fileName=""
    var position=""

    preview.ondragover=function(e)
    {
        e.preventDefault()
        e.dataTransfer.dropEffect = 'copy';
    }

    //拖动文件
    preview.ondrop=function(e)
    {
        var fileU=document.getElementById("file")
        e.preventDefault()
        file=e.dataTransfer.files[0]
        fileName=e.dataTransfer.files[0].name
        previewShowFile(file)
    }

    // 选择文件
    selectFile.onclick=function()
    {
        file=""
        upFile.click();
    }

    //显示框框
    upload.onclick=function()
    {
        var iconBox=document.getElementById("iconBox")
        if(showCodeFlag==1)
        {
            alert("目前为代码模式请先返回")
            return
        }
        if(showFile.style.display=="none")
        {
            upFile.value=""
            file=""
            preview.innerHTML="<div class='SmediaBox'></div>"
            position=document.getSelection()
            // showFile.sthle.left="161px"
            // showFile.sthle.left="200px"
            showFile.style.display="block"
            closeIndex("showFile")
            if(iconBox.style.position!="fixed")
            {
                showFile.style.left=(box.offsetWidth-showFile.offsetWidth)/2+"px"
            }
            changBackground(preview.children[0])
            // upFile.click();
        }
        else
        {
            upFile.value=""
            file=""
            preview.innerHTML="<div class='SmediaBox'></div>"
            showFile.style.display="none"
            //closeIndex("showFile")
            showFile.style.left=(box.offsetWidth-showFile.offsetWidth)/2+"px"
            changBackground(preview.children[0])
            // upFile.click();
        }
    }

    // 确定
    uploadY.onclick=function()
    {
        if(!(file instanceof File))
        {
            file=upFile.files[0]
        }
        upFileDeal(file,fileName)
    }

    // 取消上传
    uploadC.onclick=function()
    {
        fileName=""
        url=""
        file=""
        preview.innerHTML="<div class='SmediaBox'></div>"
        showFile.style.display="none"
        upFile.value=""
        state("上传已经取消")

        setTimeout(function()
        {
            state("")
        }
        ,1000)
    }

    function upFileDeal(file="",fileName="")
    {
        var text= document.getElementById('text')
        var cls=document.getElementById("cls")
        var tL=text.innerText.replace(" ","").split("\n")
        var cL=cls.value.replace(" ","").replace("\n","")
        var getTitle=""
        var seletion = document.getSelection()
        var rang =""
        var subEd=document.getElementById("subEd")
        var newRang=document.createRange()
        //防止没有先选位置的插入
        text.focus()
        if(seletion.anchorNode==null||seletion.getRangeAt(0).commonAncestorContainer.id=='state')
        {
            alert("没有选择插入位置，即将在编辑区后插入")
            dealFocus(text,"text")
        }
        else
        {
            dealFocus(text,"select")
        }
        // rang =seletion.getRangeAt(0);
        //  if(rang.commonAncestorContainer.id!="state")
        //
        {
            //   getAtR("<br>")
            //
        }
        //防止后面添加的类，导致类获取焦点
        cls.blur()
        for(var x in tL)
        {
            if(tL[x].length!=0)
            {
                getTitle=tL[x]
                break
            }
            else
            {
                getTitle=""
            }
        }
        if(getTitle.length==0||cL.length==0)
        {
            alert("请先输入标题或分类")
            return
        }
        if(!isChineseEnglishDigit(getTitle))
        {
            alert("标题必须为中文英文数字()[]-组成")
            return
        }
        if(!isChineseEnglishDigit(cL))
        {
            alert("类别必须为中文英文数字()[]-组成")
            return
        }
        // 上面已经通过file传输了。
        if(file.type.length==0)
        {
            alert("不是文件如：xx.app,请先点击文件按钮选择文件后再点击上传")
            return
        }
        if(!(file instanceof File)||file.type.length==0)
        {
            alert("请先点击文件按钮选择文件后再点击上传")
            return
        }
        if(fileName.length==0)
        {
            fileName=upFile.files[0].name.replace(" ","")
        }
        state("准备上传......")
        var da=new Date()
        var y=da.getFullYear()
        var m=da.getMonth()+1
        var data=da.getDate()
        var h=da.getHours()
        var M=da.getMinutes()
        var s=da.getSeconds()
        fileName=getDate()+"-"+cL+"-"+getTitle+"-"+fileName
        var formData= new FormData();
        formData.append("file", file);
        formData.append("cls",cL)
        formData.append("fc","uploadImg")
        formData.append("fileName",fileName)
        formData.append("dataFlag",cL+"#-#"+getTitle)
        formData.append("subEd",subEd.value)
        formData.append("oDataFlag",oDataFlag.value)
        getFileSize=file.size/1048576
        if(getFileSize>setSize)
        {
            alert("js:文件超过设定大小，请在服务器修改")
            return ;
        }

        setTimeout(function()
        {
            ajax(formData,uploadUrl,"0",dealResponse,fileName)
        }
        ,1000)

        //处理分类抢焦点问题
        function dealFocus(text,fl="select")
        {
            var delEl=document.getElementById("#flag#")
            var ele=document.createElement("span")
            ele.id="#flag#"
            if(delEl!=null&&delEl!=undefined)
            {
                delEl.parentNode.removeChild(delEl)
            }
            if(fl=="select")
            {
                var rang=document.getSelection().getRangeAt(0)
                rang.insertNode(ele)
            }
            else
            {
                text.appendChild(ele)
            }
        }

        //服务器返回处理
        function dealResponse(e)
        {
            var saveData=document.getElementById("saveData")

            //加载媒体
            function loadMedia(f=1)
            {
                if(f==0)
                {

                    setTimeout(function()
                    {
                        state("加载完成")
                    }
                    ,1000)
                }
                else
                {
                    state("加载完成")
                }
                upFile.value=""
                fileName=""
                file=""
                preview.innerHTML="<div class='SmediaBox'></div>"

                setTimeout(function()
                {
                    state("准备保存")

                    setTimeout(function()
                    {
                        saveData.click()
                    }
                    ,1000)
                }
                ,1000)
            }
            console.log("图片上传服务器反馈:"+e)
            //由于php服务器设定了一定的上传文件大小，超过的大小返回空，所以这里要提醒
            dealFocus(text,"select")
            if(e.length==0)
            {
                alert("php:文件超过设定大小，请在服务器修改")
                return ;
            }
            if(e=="changeNameOrClass")
            {
                alert("名称和类型都重复,请修改")
                document.getElementById("subEd").value="no"
                return
            }
            oDataFlag.value=cL+"#-#"+getTitle
            //通过直接从js获得名称方式解决：视频文件太大返回的名称不知道为啥为空
            srcd=fileURL+fileName
            if(srcd.indexOf(".mp4")!=-1)
            {
                var media=document.createElement("video")
                media.setAttribute("src",srcd)
                media.setAttribute("controls","controls")
                media.setAttribute("onclick","clf(this)")
            }
            else if(srcd.indexOf(".jpg")!=-1||srcd.indexOf(".jpeg")!=-1||srcd.indexOf(".png")!=-1||srcd.indexOf(".gif")!=-1||srcd.indexOf(".webp")!=-1)
            {
                var media=document.createElement("img")
                media.setAttribute("src",srcd)
            }
            else if(srcd.indexOf(".mp3")!=-1)
            {
                var media=document.createElement("audio")
                media.setAttribute("src",srcd)
                media.setAttribute("controls","controls")
            }
            else
            {
                var media=document.createElement("a")
                media.innerHTML=fileName
                media.setAttribute("href",srcd)
                media.setAttribute("target","view_window")
            }
            var br=document.createElement("br")
            var p=document.createElement("p")
            var p2=document.createElement("p")
            media.setAttribute("class","#-media")
            media.setAttribute("width","60%;")
            media.style.display="block"
            media.style.margin="0 auto"
            media.style.border="1px solid #ccc"
            media.style.padding="10px"
            var flag=document.getElementById("#flag#")
            var parent=flag.parentElement
            var oldbr=parent.getElementsByTagName("br")
            var len=oldbr.length
            parent.appendChild(media)
            p.appendChild(br)
            parent.parentElement.insertBefore(p,parent.nextSibling)
            for(var pj=len-1;pj>=0;pj--)
            {
                parent.removeChild(oldbr[pj])
            }
            parent.removeChild(flag)
            // showFile.style.display="none"
            if(media.tagName=="IMG")
            {
                var selection =position;
                var range = selection.getRangeAt(0);
                // 获取当前光标位置
                var startOffset = range.startOffset;
                // 移动光标位置
                range.setStart(p, startOffset + 1);
                range.setEnd(p, startOffset + 1);
                selection.removeAllRanges();
                selection.addRange(range);
                media.onload=loadMedia
            }
            else
            {
                loadMedia(0)
            }
        }
        return
    }

    upFile.onchange=function()
    {
        previewShowFile(upFile.files[0])
    }

    //选中文件后进行预览
    function previewShowFile(file)
    {
        url =window.URL.createObjectURL(file)
        fileName=file.name
        if (fileName.indexOf(".mp4")!=-1)
        {
            el.innerHTML="<video class='Smedia' controls='controls' style='width:100%;height:100%'  src='"+url+"'/>"
        }
        else if (fileName.indexOf(".jpg")!=-1||fileName.indexOf(".jpeg")!=-1||fileName.indexOf(".png")!=-1||fileName.indexOf(".gif")!=-1||fileName.indexOf(".webp")!=-1)
        {
            el.innerHTML="<img class='Smedia' src='"+url+"'/ style='width:100%;height:100%;'>"
        }
        else if (fileName.indexOf(".mp3")!=-1)
        {
            el.innerHTML="<audio class='Smedia' controls='controls' src='"+url+"'  style='width:100%;height:100%'/></audio>"
        }
        else
        {
            el.innerHTML="<a class='Smedia' href='"+url+"''>"+fileName.replace("C:\\fakepath\\","")+"</a>"
        }
    }

    //托选是改变背景颜色
    function  changBackground(ob)
    {

        ob.ondragenter=function(e)
        {
            this.style.backgroundColor="#ffffff35"
        }

        ob.ondragleave=function(e)
        {
            this.style.backgroundColor="#ffffff55"
        }
    }
}

// ajax
function ajax(data,ulr,type,func,fileName="")
{
    var httpRequest=new XMLHttpRequest()
    httpRequest.open("POST",ulr,true)
    if(type=="text")
    {
    }
    if(type=="json")
    {
        var head="application/json"
        httpRequest.setRequestHeader("Content-Type", head);
    }

    httpRequest.onreadystatechange = function ()
    {
        if (httpRequest.readyState == 4 && httpRequest.status == 200)
        {
            flag=httpRequest.responseText.replace(/\s*/ig,"")
            return func(flag)
        }
    }
    if(type=="json")
    {
        httpRequest.send(JSON.stringify(data))
    }
    else
    {

        function progressFunction(e)
        {
            if(e.lengthComputable)
            {
                percent=Math.round(e.loaded/e.total*100).toString()
                if(fileName.length==0)
                {
                    state("上传已经取消")

                    setTimeout(function()
                    {
                        state("")
                    }
                    ,1000)
                    return
                }
                state("已经上传"+percent+"%")
                if(percent=="100")
                {
                    state("正在加载......")
                    document.getElementById("showFile").style.display="none"
                }
            }
        }
        httpRequest.upload.onprogress=progressFunction
        httpRequest.send(data)
    }
}

//选中标题
function showH()
{
    var sh=document.getElementById("HIco")
    var H=document.getElementById("H")

    sh.onclick=function(event)
    {
        if(showCodeFlag==1)
        {
            alert("目前为代码模式请先返回")
            return
        }
        closeIndex("H")
        if( H.style.display=="none")
        {
            H.style.display="block"
            H.style.left=0+"px";
            H.style.top=40+"px"
            sh.style.color="blue"
            var text=""
            for(var i=0;i<3;i++)
            {
                text+="<button  id='h"+(i+1)+"'   onclick=song("+(i)+")>H"+(i+1)+"</buton>"
            }
            H.innerHTML=text
        }
        else
        {
            H.style.display="none"
            sh.style.color="black"
        }
    }
}

function song(s)
{
    var text=document.getElementById("text")
    if(jdS("请框选文字"))
    {
        return
    }
    var css=
    {
        "textAlign":"center","fontSize":(32-s*8)+"pt","fontWeight":"bold"
    }
    var select=document.getSelection()
    var range=select.getRangeAt(0)
    var getP=range.startContainer.parentNode
    while(true)
    {
        console.log("song(s)")
        if(getP.tagName=="P"||getP.contains(text))
        {
            break
        }
        else
        {
            getP=getP.parentNode
        }
    }

    getP.style.textAlign="center"
    getP.style.display="block"
    getP.style.fontSize=(32-s*8)+"pt"
    getP.style.fontWeight="bold"
    showHChild(getP,css)
    text.innerHTML+="<p><br></p>"
    var sh=document.getElementById("H")
    sh.style.display="none"
    // undoAandRundo()
}

//修改标题的子元素的样式
function showHChild(getP,css)
{
    var chd=getP.children
    var len=chd.length
    if(len!=0)
    {
        for(var i=0;i<len;i++)
        {
            for(key in css)
            {
                chd[i].style[key]=css[key]
            }
            showHChild(chd[i],css)
        }
    }
    else
    {
        return
    }
}

//背景色
function  Abackground()
{
    var aB=document.getElementById("ABackgrounIcon")
    var aBC=document.getElementById("bColor")

    aB.onclick=function()
    {
        if(showCodeFlag==1)
        {
            alert("目前为代码模式请先返回")
            return
        }
        closeIndex("bColor")
        if(aBC.style.display=="none")
        {
            if(jdS("请框选文字"))
            {
                return
            }
            aBC.style.display="inline-block"
            aBC.style.left=0+"px";
            aBC.style.top=40+"px"
        }
        else
        {
            aBC.style.display="none"
            $().selsectObj(
            {
                "style":"background:"+aBC.value
            }
            )
            // undoAandRundo()
        }
    }
}

//文字颜色
function  AColor()
{
    var aC=document.getElementById("AColorIcon")
    var fC=document.getElementById("fColor")

    aC.onclick=function()
    {
        if(showCodeFlag==1)
        {
            alert("目前为代码模式请先返回")
            return
        }
        closeIndex("fColor")
        if(fC.style.display=="none")
        {
            if(jdS("请框选文字"))
            {
                return
            }
            fC.style.display="inline-block"
            fC.style.left=0+"px";
            fC.style.top=40+"px"
        }
        else
        {
            fC.style.display="none"
            $().selsectObj(
            {
                "style":"color:"+fC.value
            }
            )
            // undoAandRundo()
        }
    }
}

// 显示或则关闭源码
function showOrCloseCode()
{
    var text=document.getElementById("text")
    var showCode=document.getElementById("showCode")
    var stateWorder=document.getElementById("stateWorder")

    showCode.onclick=function(e)
    {
        if(stateWorder.innerText.includes("正在加载")||stateWorder.innerText.includes("准备上传"))
        {
            alert("正在加载，不能点击源码按钮")
            return
        }
        if(showCodeFlag==0)
        {
            text.innerText=text.innerHTML
            text.style.color="blue"
            showCode.style.color="red"
            showCodeFlag=1
            closeIndex("showCode")
        }
        else
        {
            text.innerHTML=text.innerText
            text.style.color="black"
            showCode.style.color="black"
            showCodeFlag=0
        }
    }
    paseText()
    tdclick()
}
// 格式刷动作函数

function brushAction(event)
{
    if (event.button === 0)
    {
        console.log("复制格式");
        var getSelection=document.getSelection()
        var rangeCount=getSelection.rangeCount
        var te=document.getElementById("text")
        var actionAtri=""
        if(rangeCount>1)
        {
            rangeCount=1
        }
        for(var i=0;i<rangeCount;i++)
        {
            getRange=getSelection.getRangeAt(i)
            parentNode=getRange.startContainer.parentNode
            if((getRange.startContainer instanceof Text) && parentNode!=te)
            {
                actionAtri=parentNode.attributes
                format=
                {
                }
                for(var j=0;j<actionAtri.length;j++)
                {
                    format[actionAtri[j].name]=actionAtri[j].value
                }
            }
        }
        document.removeEventListener("mouseup", brushAction)
        document.addEventListener("mouseup", pastFormat)
    }
}

//张贴格式
function pastFormat(event)
{
    if (event.button === 0)
    {
        console.log("张贴格式")
        var getSelection=document.getSelection()
        var rangeCount=getSelection.rangeCount
        var getRange=""
        var clone=""
        var atri=""
        var parentNode=""
        var te=document.getElementById("text")
        for(var i=0;i<rangeCount;i++)
        {
            var temp=document.createElement("span")
            getRange=getSelection.getRangeAt(i)
            clone=getRange.cloneContents()
            temp.appendChild(clone)
            var parent=getRange.commonAncestorContainer.parentNode
            if((parent.innerHTML==temp.innerHTML||getRange.commonAncestorContainer.innerHTML==temp.innerHTML)&&parent!=te&&getRange.commonAncestorContainer!=te)
            {
                temp=getRange.commonAncestorContainer
                if(temp instanceof Text)
                {
                    temp=getRange.commonAncestorContainer.parentNode
                    for(var key in format)
                    {
                        temp[key]=format[key]
                    }
                    return
                }
            }
            child=temp.getElementsByTagName("*")
            for(var key in format)
            {
                temp[key]=format[key]
            }
            if(format.length!=0)
            {
                for(var j=0;j<child.length;j++)
                {
                    atri=child[j].attributes
                    for(var k=0;k<atri.length;k++)
                    {
                        child[j].removeAtttribute(atri[k].name)
                    }
                    for(var key in format)
                    {
                        child[j][key]=format[key]
                    }
                }
            }
            if(getRange.commonAncestorContainer.innerHTML==temp.innerHTML&&getRange.commonAncestorContainer!=te)
            {
                temp.parentNode.insertBefore(temp,temp)
            }
            else
            {
                getRange.deleteContents()
                getRange.insertNode(temp)
            }
        }
        document.removeEventListener("mouseup", pastFormat)
        // undoAandRundo()
    }
}

// 格式刷
function brush()
{
    var bru=document.getElementById("brush")

    bru.onclick=function()
    {
        if(showCodeFlag==1)
        {
            alert("目前为代码模式请先返回")
            return
        }
        var body = document.getElementsByTagName('body')[0];
        document.getSelection().collapse(body,0);
        document.addEventListener("mouseup", brushAction)
    }
}

//清除格式
function   eraser()
{
    var  eraser=document.getElementById("eraser")

    eraser.onclick=function(e)
    {
        $().selsectObj(
        {
            "style":"background:none;font-size:18px;font-weight:normal;color:black;text-align:left;text-decoration:none;font-style:none;display: block;"
        }
        )
        // undoAandRundo()
    }
}
/*以下是表格插入*/

function getDate()
{
    var date=new Date()
    var y=date.getFullYear()
    var M=date.getMonth()+1
    var d=date.getDate()
    var h=date.getHours()
    var m=date.getMinutes()
    var s=date.getSeconds()
    var li=[y,M,d,h,m,s]
    var str=""
    for(var i=0;i<li.length;i++)
    {
        if(li[i]<10)
        {
            str+="0"+li[i]
        }
        else
        {
            str+=li[i]
        }
    }
    return str
}
// 插入表格
// 下面参数是记录鼠标位置
var  lightMouse=""

function allTableFunction()
{
    var tableB=document.getElementById("tableB")
    var  showBox=document.getElementById("tableSetBox")

    tableB.onclick=function()
    {
        if(showCodeFlag==1)
        {
            alert("目前为代码模式请先返回")
            return
        }
        closeIndex("tableSetBox")
        if(showBox.style.display=="none")
        {
            showBox.style.display="inline-block"
            tableB.style.color="blue"
            lightMouse=getLight()
        }
        else
        {
            showBox.style.display="none"
            tableB.style.color="black"
        }
    }
    enterTable("text")
    addC()
    addR()
    deleC()
    deleR()
    setAddR()
    setdelR()
    setAddC()
    setdelC()
    addCW()
    delCW()
    addRW()
    delRW()
}

//显示表格高宽
function  showHW()
{
    var data=getdata()
    var showTable=document.getElementById("showTable")
    var shoW=document.getElementById("shoW")
    if(Object.keys(data)[0]!=undefined&&Object.keys(data)[0].includes("tr"))
    {
        var r=document.getElementById(Object.keys(data)[0]).parentNode.getElementsByTagName("tr").length
        var c=document.getElementById(Object.keys(data)[0]).getElementsByTagName("td").length
        var td=document.getElementById(Object.keys(data)[0]).getElementsByClassName(data[Object.keys(data)[0]])[0]
        if( data[Object.keys(data)[0]].length!=0&&data[Object.keys(data)[0]].includes("td"))
        {
            showTable.innerText=r+"x"+c
            var tdw=parseInt(td.style.width.replace("%","").replace("px",""))
            var tdh=parseInt(td.style.height.replace("%","").replace("px",""))
            shoW.innerText=tdw+"px"+tdh+"p"
        }
        else
        {
            showTable.innerText="行数x列数"
            shoW.innerText="行宽x列宽"
        }
    }
}

function enterTable(box)
{
    var text=document.getElementById(box)
    var child=text.children
    var tB=document.getElementById("insertTableYes")
    var tableSetBox=document.getElementById("tableSetBox")
    var tableB=document.getElementById("tableB")

    insertTableYes.onclick=function()
    {
        var trtd=[parseInt(document.getElementById("setR").value),parseInt(document.getElementById("setC").value)]
        var table = document.createElement('table');
        var tbody = document.createElement('tbody');
        var p=document.createElement('p');
        var date=getDate()
        table.id="table"+date
        table.style.width="800px"
        table.style.borderCollapse="collapse"
        table.style.display="block"
        table.style.textAlign="center"
        table.style.margin="0 auto"  /* 上下保持为0，左右自动适应 */
        table.style.display="block" /* 确保表格作为块级元素显示 */
        table.style.textAlign="center" /* 表格内的文本居中 */
        tbody.style.display="block"
        tbody.style.width="100%"
        if(lightMouse=="no")
        {
            alert("请先选择编辑器")
            return
        }
        if(jdS("请选择插入位置","enter"))
        {
            return
        }
        for(var r=0;r<trtd[0];r++)
        {
            var tr=document.createElement("tr")
            tr.id=table.id+"tr"+(r+1)
            tr.style.width="100%"
            tr.style.display="inline-block"
            for(var c=0;c<trtd[1];c++)
            {
                var td=document.createElement("td")
                td.className=table.id+"td"+(c+1)
                td.class="tb"
                td.style.wordWrap="break-word"
                td.style.wordBreak="break-all"
                td.style.whiteSpace="normal"
                td.style.minWidth="50px"
                td.style.height="30px"
                //必须使用block和float否则导致不能张贴内容,这里是以前的
                // td.style.display="block"
                // td.style.float="left"
                td.style.width=parseInt(parseInt(table.style.width.replace("px",""))/trtd[1])+"px"
                td.style.border="1px dashed #ccc"
                tr.appendChild(td)
            }
            tbody.appendChild(tr)
            table.appendChild(tbody)
        }
        //由于规定编辑框中要为p的独立块，其中在记录函数中
        // 有这项检查，所以这里必须包装为p
        p.appendChild(table)
        lightMouse.insertNode(lightMouse.createContextualFragment(p.innerHTML))
        tableSetBox.style.display="none"
        tableB.style.color="black"
        tdclick()
        paseText()
        var getTabel=document.getElementById("table"+date)
        var tableChil=getTabel.parentElement.getElementsByTagName("br")
        for(var i=tableChil.length-1;i>0;i--)
        {
            etTabel.parentElement.removeChild(tableChil[i])
        }
        //解决后面没有单独一行的问题
        if(child[child.length-1].innerHTML.replace(/\s+/ig)!="<br>")
        {
            var pBr=document.createElement("p")
            pBr.innerHTML="<br>"
            text.appendChild(pBr)
        }
        // undoAandRundo()
    }
}

//删除列
function deleC()
{
    var delC=document.getElementById("delC")
    var showRC=document.getElementById("showTable")
    var select=document.getSelection()

    delC.onclick=function()
    {
        var data=getdata()
        var values=data[Object.keys(data)[0]]
        if(values==null||values==undefined||values.length==0||!data[Object.keys(data)[0]].includes("td"))
        {
            alert("请选择表格")
            return
        }
        if(data[Object.keys(data)[0]].length==0)
        {
            alert("没有选中单元格")
            return
        }
        var table=document.getElementById(Object.keys(data)[0]).parentNode
        if(table.tagName=="TBODY")
        {
            table=table.parentNode
        }
        var tr=document.getElementById(Object.keys(data)[0])
        if(tr.children.length==1)
        {
            alert("最后一列了，不能删除")
            return
        }
        var deleList=[]
        for(var key in data)
        {
            var deleElementList= document.getElementsByClassName(data[key])
            for(var i=0;i<deleElementList.length;i++ )
            {
                deleElementList[i].parentNode.removeChild(deleElementList[i])
                i-=1
            }
            var ns=showRC.innerText.split("x")
            showRC.innerText= ns[0]+"x"+(parseInt(ns[1])-1)
        }
        setIdClass(table)
        // data=getdata()
        select.removeAllRanges();
        var tdL=tr.getElementsByTagName("td").length
        var showTable=document.getElementById("showTable")
        showTable.innerText=showTable.innerText.split("x")[0]+"x" +parseInt(tdL)
        // undoAandRundo()
    }
}

//删除行
function  deleR()
{
    var editR=document.getElementById("delR")
    var showRC=document.getElementById("showTable")

    editR.onclick=function()
    {
        var data=getdata()
        var values=data[Object.keys(data)[0]]
        if(values==null||values==undefined||values.length==0||!data[Object.keys(data)[0]].includes("td"))
        {
            alert("请选择表格")
            return
        }
        if(data[Object.keys(data)[0]].length==0)
        {
            alert("没有选中单元格")
            return
        }
        var table=document.getElementById(Object.keys(data)[0]).parentNode
        if(table.tagName=="TBODY")
        {
            table=table.parentNode
        }
        var tr=table.getElementsByTagName("tr")
        if(tr.length==1)
        {
            alert("最后一行了，不能删除")
            return
        }
        for(var key in data)
        {
            var deleElementList=document.getElementById(key)
            deleElementList.parentNode.removeChild(deleElementList)
        }
        var ns=showRC.innerText.split("x")
        showRC.innerText= (parseInt(ns[0])-1)+"x"+ns[1]
        setIdClass(table)
        var trL=tr.length
        var showTable=document.getElementById("showTable")
        showTable.innerText=parseInt(trL)+"x"+showTable.innerText.split("x")[1]
        // undoAandRundo()
    }
}

//添加列
function  addC()
{
    var addC=document.getElementById("addC")
    var showRC=document.getElementById("showTable")
    var divContainer=document.createElement("div")
    var text=document.getElementById("text")

    addC.onclick=function()
    {
        var data=getdata()
        var length=0
        console.log(data)
        if(Object.keys(data).length==0||!data[Object.keys(data)[0]].includes("td"))
        {
            alert("没有选中单元格")
            return
        }
        console.log(data)
        var getTr=document.getElementById(Object.keys(data)[0])
        var hang=getTr.getElementsByTagName("td")
        for(var w=0;w<hang.length;w++)
        {
            length+=hang[w].offsetWidth
        }
        length+=document.getElementsByClassName(data[Object.keys(data)[0]])[0].offsetWidth
        if(length+20>text.offsetWidth)
        {
            alert("由于编辑框宽度限制，不能再添加列")
            return
        }
        var table=getTr.parentNode
        if(table.tagName=="TBODY")
        {
            table=table.parentNode
        }
        for(var key in data)
        {
            var cell=document.getElementsByClassName(data[key])
            var clen=cell.length
            for(var j=0;j<clen;j++)
            {
                var attri=cell[j].attributes
                var newCell=document.createElement("td")
                for(var i=0;i<attri.length;i++)
                {
                    newCell.setAttribute(attri[i].name,attri[i].value)
                }
                newCell.setAttribute("class","newtd")
                newCell.onclick=showHW
                cell[j].parentNode.insertBefore(newCell,cell[j].nextSibling)
            }
        }
        var ns=showRC.innerText.split("x")
        showRC.innerText= ns[0]+"x"+ (parseInt(ns[1])+1)
        setIdClass(table)
        var tdL=getTr.getElementsByTagName("td").length
        var showTable=document.getElementById("showTable")
        showTable.innerText=showTable.innerText.split("x")[0]+"x" +parseInt(tdL)
        // undoAandRundo()
    }
}

//添加行
function addR()
{
    var addR=document.getElementById("addR")
    var showRC=document.getElementById("showTable")

    addR.onclick=function()
    {
        var data=getdata()
        if(Object.keys(data).length==0||!data[Object.keys(data)[0]].includes("td"))
        {
            alert("没有选中单元格")
            return
        }
        var table=document.getElementById(Object.keys(data)[0]).parentNode
        if(table.tagName=="TBODY")
        {
            table=table.parentNode
        }
        for(var key in data)
        {
            var tr=document.getElementById(key)
            var newTr=document.createElement("tr")
            var child=tr.childNodes
            var trAtir=tr.attributes
            var trAtirLen=trAtir.length
            for(var j=0;j<trAtirLen;j++)
            {
                newTr.setAttribute(trAtir[j].name,trAtir[j].value)
            }
            newTr.id="newTr"
            for(var i=0;i<child.length;i++)
            {
                var newTd=document.createElement("td")
                var tdAtir=child[i].attributes
                var tdAtirLen=tdAtir.length
                for(var k=0;k<tdAtirLen;k++)
                {
                    newTd.setAttribute(tdAtir[k].name,tdAtir[k].value)
                }
                // newTd.style.height="30px"
                newTd.onclick=showHW
                newTd.className="newTd"
                newTr.appendChild(newTd)
            }
            var ns=showRC.innerText.split("x")
            showRC.innerText=(parseInt(ns[0])+1) +"x"+ ns[1]
        }
        tr.parentNode.insertBefore(newTr,tr.nextSibling)
        // data=getdata()
        setIdClass(table)
        var trL=table.getElementsByTagName("tr").length
        var showTable=document.getElementById("showTable")
        showTable.innerText=parseInt(trL)+"x"+showTable.innerText.split("x")[1]
        // undoAandRundo()
    }
}
dX=0
uX=0
getDX=0

function judgmentDirection()
{

    document.addEventListener('mousedown', function(event)
    {
        getDX= event.clientX
    }
    );

    document.addEventListener('mouseup', function(event)
    {
        if(getDX!=event.clientX)
        {
            dX=getDX
            uX= event.clientX
        }
    }
    );
}
judgmentDirection()

//解决获取表格的定位的问题
function  getdata()
{
    var select=document.getSelection()
    var text=document.getElementById('text')
    var rang=""
    var pr=
    {
    }
    var id=""
    var cls=""
    for(var i=0;i<select.rangeCount;i++)
    {
        rang=select.getRangeAt(i)
        if(rang.startOffset==rang.endOffset)
        {
            if(rang.startContainer instanceof Text)
            {
                id=rang.startContainer
                while((id.id==undefined||id.id.replace(/\s+/ig,"").length==0)&&id!=text&&id.tagName!="TR")
                {
                    id=id.parentNode
                }
                cls=rang.startContainer
                while((cls.className==null||cls.className==undefined||cls.className.replace(/\s+/ig,"").length==0)&&cls!=text&&cls.tagName!="TD")
                {
                    cls=cls.parentNode
                }
                pr[id.id]=cls.className
            }
            else if(rang.startContainer.tagName=="TR")
            {
                pr[rang.startContainer.id]=rang.startContainer.childNodes[0].className
            }
            else
            {
                pr[rang.startContainer.parentNode.id]=rang.startContainer.className
            }
        }
        else if(rang.commonAncestorContainer.tagName=="TR" && rang.startOffset!=rang.endOffset)
        {
            if((uX-dX)>0)
            {
                pr[rang.startContainer.parentNode.parentNode.id]=rang.startContainer.parentNode.className
            }
            else
            {
                pr[rang.endContainer.parentNode.parentNode.id]=rang.endContainer.parentNode.className
            }
        }
        else
        {
            if(rang.startContainer instanceof Text && rang.startContainer==rang.endContainer)
            {
                pr[rang.startContainer.parentNode.parentNode.id]=rang.startContainer.parentNode.className
            }
            else if(rang.startContainer.tagName!="P")
            {
                // alert("删除或添加行列只能选一格")
            }
            else
            {
            }
        }
    }
    return pr
}

//重新设置id和class
function  setIdClass(table)
{
    var tr=table.getElementsByTagName("tr")
    var tb=table
    var del=tb.getElementsByTagName("td")
    //删除空的表格
    if(del.length==0)
    {
        tb.parentNode.removeChild(tb)
        return
    }
    if(tb.tagName="TBODY")
    {
        tb=tb.parentNode
    }
    for(var i=0;i<tr.length;i++)
    {
        var td=tr[i].getElementsByTagName("td")
        for(var j=0;j<td.length;j++)
        {
            td[j].setAttribute("class",table.id+"td"+(j+1))
        }
        tr[i].setAttribute("id",table.id+"tr"+(i+1))
    }
}

//设定加行数
function  setAddR()
{
    var setR=document.getElementById("setR")
    var addR=document.getElementsByClassName("insert")[0]

    addR.onclick=function()
    {
        setR.value=parseInt(setR.value)+1
    }
}

//设定减行数
function  setdelR()
{
    var setR=document.getElementById("setR")
    var addR=document.getElementsByClassName("insert")[2]

    addR.onclick=function()
    {
        if(parseInt(setR.value)>1)
        {
            setR.value=parseInt(setR.value)-1
        }
        else
        {
            alert("最少一行")
        }
    }
}

//设定加列数
function  setAddC()
{
    var setC=document.getElementById("setC")
    var addC=document.getElementsByClassName("insert")[1]

    addC.onclick=function()
    {
        setC.value=parseInt(setC.value)+1
    }
}

//设定减行数
function  setdelC()
{
    var setC=document.getElementById("setC")
    var addC=document.getElementsByClassName("insert")[3]

    addC.onclick=function()
    {
        if(parseInt(setC.value)>1)
        {
            setC.value=parseInt(setC.value)-1
        }
        else
        {
            alert("最少一行")
        }
        // undoAandRundo()
    }
}

// 增加宽度
function addCW()
{
    var addCW=document.getElementById("addCW")

    addCW.onclick=function()
    {
        var data=getdata()
        var values=data[Object.keys(data)[0]]
        if(values==null||values==undefined||values.length==0||!data[Object.keys(data)[0]].includes("td"))
        {
            alert("请选择表格")
            return
        }
        var text=document.getElementById("text")
        var shoW=document.getElementById("shoW")
        var td=document.getElementsByClassName(data[Object.keys(data)[0]])
        var tds=document.getElementById(Object.keys(data)[0]).getElementsByTagName("td")
        var length=0
        for(var ts=0;ts<tds.length;ts++)
        {
            length+=tds[ts].offsetWidth
        }
        if(length+23>text.offsetWidth)
        {
            alert("由于编辑框宽度现在，不能再增加宽度")
            return
        }
        var w=parseInt(td[0].style.width.replace("%","").replace("%",""))
        if(w<800)
        {
            for(var i=0;i<td.length;i++)
            {
                td[i].style.width=(w+1)+"px"
                var sp=shoW.innerText.split("x")
                shoW.innerText=td[i].style.width+sp[1]
            }
        }
        // undoAandRundo()
    }
}

//减少宽度
function delCW()
{
    var delCW=document.getElementById("delCW")

    delCW.onclick=function()
    {
        var data=getdata()
        var values=data[Object.keys(data)[0]]
        var shoW=document.getElementById("shoW")
        if(values==undefined||values==null||values.length==0||!data[Object.keys(data)[0]].includes("td"))
        {
            alert("请选择表格")
            return
        }
        var td=document.getElementsByClassName(data[Object.keys(data)[0]])
        var w=parseInt(td[0].style.width.replace("%","").replace("%",""))
        if(w>5)
        {
            for(var i=0;i<td.length;i++)
            {
                td[i].style.width=(w-1)+"px"
                var sp=shoW.innerText.split("x")
                shoW.innerText=td[i].style.width+sp[1]
            }
        }
        // undoAandRundo()
    }
}

// 增加高度
function addRW()
{
    var addRW=document.getElementById("addRW")

    addRW.onclick=function()
    {
        var data=getdata()
        var values=data[Object.keys(data)[0]]
        if(values==null||values==undefined||values.length==0||!data[Object.keys(data)[0]].includes("td"))
        {
            alert("请选择表格")
            return
        }
        var shoW=document.getElementById("shoW")
        var tr=document.getElementById(Object.keys(data)[0])
        var td=tr.getElementsByTagName("td")
        var h=parseFloat(td[0].style.height.replace("px","").replace("%","").replace("em",""))
        if(h<100)
        {
            for(var i=0;i<td.length;i++)
            {
                td[i].style.height=(h+1)+"px"
                var sp=shoW.innerText.split("x")
                shoW.innerText=sp[0]+"x"+td[i].style.height.replace("x","")
            }
        }
        // undoAandRundo()
    }
}

//减少高度
function delRW()
{
    var delRW=document.getElementById("delRW")

    delRW.onclick=function()
    {
        var data=getdata()
        var values=data[Object.keys(data)[0]]
        if(values==null||values==undefined||values.length==0||!data[Object.keys(data)[0]].includes("td"))
        {
            alert("请选择表格")
            return
        }
        var shoW=document.getElementById("shoW")
        var tr=document.getElementById(Object.keys(data)[0])
        var td=tr.getElementsByTagName("td")
        var h=parseFloat(td[0].style.height.replace("px","").replace("%","").replace("em",""))
        if(h>5)
        {
            for(var i=0;i<td.length;i++)
            {
                td[i].style.height=(h-1)+"px"
                var sp=shoW.innerText.split("x")
                shoW.innerText=sp[0]+"x"+td[i].style.height.replace("x","")
            }
        }
        // undoAandRundo()
    }
}
/*以上是插入表格*/

//保存
function saveData()
{
    var saveData=document.getElementById("saveData")

    saveData.onclick=function()
    {
        closeIndex("saveData")
        var text=document.getElementById("text")
        var tL=text.innerText.replace(" ","").split("\n")
        var getTitle=""
        var cls=document.getElementById("cls")
        var cL=cls.value.replace(" ","").replace("\n","")
        var text=document.getElementById("text")
        var dataFlag=""
        var content=text.innerHTML
        var oDataFlage=document.getElementById("oDataFlag").value.replace(/\s*/ig,"")
        var mediaList=document.getElementsByClassName("#-media")
        var media=[]
        if(showCodeFlag==1)
        {
            alert("目前为代码模式请先返回")
            return
        }
        for(var x in tL)
        {
            if(tL[x].length!=0)
            {
                getTitle=tL[x]
                break
            }
            else
            {
                getTitle=""
            }
        }
        if(cls.value.length==0)
        {
            alert("请填写分类")
            return;
        }
        if(getTitle.length==0)
        {
            alert("标题为空")
            return;
        }
        if(!isChineseEnglishDigit(getTitle))
        {
            alert("标题必须为中文英文数字()[]-组成")
            return
        }
        if(!isChineseEnglishDigit(cL))
        {
            alert("类别必须为中文英文数字()[]-组成")
            return
        }
        dataFlag=(cL+"#-#"+getTitle).replace(/\s*/ig,"")
        for(var i=0;i<mediaList.length;i++)
        {
            var Ur=mediaList[i].getAttribute("src")
            if(Ur==null)
            {
                Ur=mediaList[i].getAttribute("href")
            }
            // "../.."+解决图片上传所登录的地址不一样的问题
            media.push("../.."+Ur)
        }
        oMedia=media
        // return
        var data=
        {
            "dataFlag":dataFlag,
            "content":content,
            "oDataFlag":oDataFlage,
            "media":media,
            "subEd":document.getElementById("subEd").value,
            "ls=":cL,
            "fc":"saveData"
        }

        ajax(data,"dealCenter.php","json",function(e)
        {
            if(e=="ok")
            {
                state("保存成功","yes")
                document.getElementById("subEd").value="yes"
                document.getElementById("oDataFlag").value=dataFlag
                document.getElementById("oMedia").value=media
                document.getElementById("contents").value=content
                document.getElementsByTagName("title")[0].innerText=getTitle

                setTimeout(function()
                {
                    state("")
                }
                ,3000)
            }
            else if(e=="changeNameOrClass")
            {
                alert("名称和类型都重复")
                document.getElementById("subEd").value="no"
            }
            else
            {
                alert("保存失败")
                state("保存失败")
            }
        }
        )
    }
}

//编辑加载
function  loadText()
{
    var url=location.href
    var getCls=""
    var text=document.getElementById("text")
    var content=document.getElementById("contents")
    if(openTabelEdite==0)
    {
        editeTable()
        openTabelEdite=1
    }
    if(url.includes("?")&&url.includes("&"))
    {
        getCls=url.split("?")[1].split("&")
    }
    else if(url.includes("?")&&!url.includes("&"))
    {
        getCls=url.split("?")
    }
    else
    {
        return
    }
    var cls=document.getElementById("cls")
    for(var i=0;i<getCls.length;i++)
    {
        if(getCls[i].includes("cls="))
        {
            cls.value=decodeURIComponent(getCls[i].split("cls=")[1].replace(" ","").replace("\n",""))
        }
        if(getCls[i].includes("title="))
        {
            document.getElementsByTagName("title")[0].innerText=decodeURIComponent(getCls[i].split("title=")[1].replace(" ","").replace("\n",""))
        }
    }
    text.innerHTML=content.value
    // undoAandRundo()
    tdclick()
    paseText()
}

//获取字体表
function setFont()
{
    var fontFamily=document.getElementById("fontFamily")
    var fonts=["仿宋_gb2312","楷体_gb2312","方正小标宋","新魏体","武林江湖体","宋体_粗","微软雅黑_细","微软雅黑","微软雅黑_粗","沧浪行楷","清平手书","飞天手书"]
    var fontList=[]
    var showF=document.getElementById("showF")
    for(var i=0;i<fonts.length;i++)
    {
        var f=fonts[i].replace(/\s/ig,"#")
        showF.innerHTML+="<button onclick=changF('"+f+"') style='font-family:"+f+";'>"+fonts[i]+"</button>"
    }

    fontFamily.onclick=function()
    {
        if(showCodeFlag==1)
        {
            alert("目前为代码模式请先返回")
            return
        }
        closeIndex("showF")
        var  showF=document.getElementById("showF")
        if(showF.style.display=="none")
        {
            showF.style.display="block"
            showF.style.left=0+"px";
            showF.style.top=40+"px"
            fontFamily.style.color="blue"
        }
        else
        {
            showF.style.display="none"
            fontFamily.style.color="black"
        }
    }
}

//选择字体
function changF(font)
{
    if(jdS("请框选文字"))
    {
        return
    }
    $().selsectObj(
    {
        "style":"fontFamily:"+font.replace(/#+/ig," ")
    }
    )
    // undoAandRundo()
}

//点击关闭其它按钮框
function closeIndex(falg)
{
    var cp=["showF","showFontSize","bColor","fColor","H","tableSetBox","showFile"]
    for(var i=0;i<cp.length;i++)
    {
        if(falg!=cp[i])
        {
            var ele=document.getElementById(cp[i])
            ele.style.display="none"
        }
    }
    var fontFamily=document.getElementById("fontFamily")
    var tt=document.getElementById("tt")
    var HIco=document.getElementById("HIco")
    var tableB=document.getElementById("tableB")
    fontFamily.style.color="black"
    tt.style.color="black"
    HIco.style.color="black"
    tableB.style.color="black"
}

//保存快捷键
document.addEventListener('keydown', function(e)
{
    var saveData=document.getElementById("saveData")
    if (e.keyCode == 83 && (navigator.platform.match("Mac") ? e.metaKey : e.ctrlKey))
    {
        e.preventDefault()
        if(showCodeFlag==1)
        {
            alert("目前为代码模式请先返回")
            return
        }
        saveData.click()
    }
    if((e.ctrlKey==true|e.metaKey==true)&&e.key=="i")
    { console.log(88)
        e.preventDefault()
        var m=document.getElementById("iconBox")
        var showFile=document.getElementById("showFile")
        var windowWidth = document.getElementById("box")
        var iconBox = document.getElementById("iconBox")
        if( m.style.position!="fixed")
        {
            m.style.position="fixed"
            m.style.top="0px"
            m.style.zIndex="500"
            m.style.left=(document.getElementsByTagName("body")[0].offsetWidth-windowWidth.offsetWidth)/2+8+"px"
            console.log(windowWidth.offsetWidth,document.getElementsByTagName("body")[0].offsetWidth)
            showFile.style.position="fixed"
            showFile.style.left=(document.getElementsByTagName("body")[0].offsetWidth)/3+"px"
            //iconBox.style.width=document.getElementById("box").offsetWidth+"px"
            iconBox.style.width=(document.getElementById("text").offsetWidth)+"px"
        }
        else
        {
             console.log(99)
            //m.style.position="relative"
            //m.style.top="0px"
            m.removeAttribute("style")
            showFile.style.position="absolute"
            showFile.style.zindex="10000"
            //m.style.border="none"
            //m.style.borderLeft="1px solid #ccc"
            //m.style.borderRight="1px solid #ccc"
            //m.style.borderTop="1px solid #ccc"
        }
    }
}
);

//给表格添加点击
function addClick()
{
    var td=document.getElementsByTagName("td")
    for(var i=0;i<td.length;i++)
    {
        td.onclick=showHW
    }
}
//移动东西

function move(e,obel)
{
    var x=0
    var y=0
    var gx=0
    var gy=0
    var li=["tableSetBox","fColor","bColor","showFontSize","showF","H","showFile"]
    var cli=["setR","setC"]
    for(var i=0;i<li.length;i++)
    {
        //必须使用一个函数进行包装否则li[i]
        //首先没有赋值，点击后才赋值，这时i
        //已经变动
        pack(li[i])
    }
    for(var i=0;i<cli.length;i++)
    {
        //阻止子元素的行为
        stopP(document.getElementById(cli[i]))
    }

    //阻止子元素的行为
    function stopP(el)
    {

        el.onmousemove=function(e)
        {
            e.stopPropagation()
        }
    }

    //移动行数
    function  toMove(e,obel)
    {
        var lf=obel.offsetLeft
        var tp=obel.offsetTop
        if(tp==null||tp==undefined||tp.length==0)
        {
            tp=0
        }
        if(lf==null||lf==undefined||lf.length==0)
        {
            lf=0
        }
        //当滚动第一步时clientX-x这时是1，
        //当滚动第二步时不能只是clientX-x这时得到2，
        // 由于前面有了1，这里的2中有原来的1。如果直接加减
        // 导致数值累计。所以从第二步开始是现在的位置减去
        // 前面的位置，同时不能再减去最开始的方块所在位置了。
        obel.style.left=lf+(e.clientX-gx-x)+"px"
        obel.style.top=tp+(e.clientY-gy-y)+"px"
        gx=e.clientX
        gy=e.clientY
        x=0
        y=0
    }

    //包装函数，解决i变动问题
    function pack(ob)
    {
        var el=document.getElementById(ob)

        el.onmousedown=function(e)
        {
            x=e.clientX
            y=e.clientY
            document.onmousemove=(e)=>toMove(e,el)
        }

        document.onmouseup=function(e)
        {
            x=0
            y=0
            gx=0
            gy=0
            document.onmousemove=null
        }
    }
}

//判断选择
function jdS(string="",flag="select")
{
    var seletion=document.getSelection()
    //防止没有先选位置的插入
    if(seletion.anchorNode==null && flag=="select")
    {
        if(string.length==0)
        {
            alert("请选择插入的位置")
        }
        else
        {
            alert(string)
        }
        return true
    }
    else if(seletion.anchorNode==null && flag=="enter" && seletion.anchorOffset==seletion.focusOffset)
    {
        if(string.length==0)
        {
            alert("请选择插入的位置")
        }
        else
        {
            alert(string)
        }
        return true
    }
    else
    {
        return false;
    }
}

function isMobile()
{
    const regExp = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i;
    return regExp.test(navigator.userAgent);
}

function isChineseEnglishDigit(str)
{
    return /^[A-Za-z0-9\u4e00-\u9fa5\(\)（）\[\]-]+$/.test(str);
}

//标注*
// function dimension()
//
{

    // var text=document.getElementById("text")
    // text.onkeydown=function(e)
    //
    {
        // var startPostion=text.selectionStart
        //var selection=document.getSelection()
        //var range=selection.getRangeAt(0)
        //console.log(range.endContainer)
        // if((e.metaKey && e.keyCode==191)||(e.ctrlKey&&e.keyCode==191) )
        //
        {
            // undoAandRundo()
            // content=range.cloneContents()
            // var span=document.createElement("span")
            // var parent=range.startContainer
            // var startP=range.startContainer
            // while(true)
            //
            {
                // if(startP.tagName!="P")
                //
                {
                    //startP=startP.parentNode
                    //
                }
                // else
                {
                    // break
                    //
                }
                //
            }
            // while(true)
            //
            {
                // if(parent.tagName!="P")
                //
                {
                    //parent=parent.parentNode
                    //
                }
                // else
                {
                    // break
                    //
                }
                //
            }
            // var sp=parent.innerHTML.split("&nbsp;")
            // var str=""
            // var flag=0
            // for(var i=0;i<sp.length;i++)
            //
            {
                // console.log(sp[i])
                // if(sp[i].replace(/\s+/ig,"").length==0)
                //
                {
                    // str+="&nbsp;"
                    //
                }
                // else
                //
                {
                    // if( sp[i].includes("//"))
                    //
                    {
                        // str+=sp[i].replace(/\/\//ig,"")
                        //
                    }
                    // else
                    //
                    {
                        // if(flag==0 )
                        //
                        {
                            // str+="//"
                            // flag=1
                            //
                        }
                        // str+=sp[i]
                        //
                    }
                    //
                }
                //
            }
            // console.log(startP)
            // startP.innerHTML=str
            // selection.selectAllChildren(startP.childNodes[0])
            // selection.collapseToEnd()
            //
        }
        //
    }
    //
}

function addDiagonal()
{

    document.onkeydown=function(e)
    {
        if((e.metaKey && e.keyCode==191)||(e.ctrlKey&&e.keyCode==191))
        {
            var text=document.getElementById("text")
            addp(text)
            var selection=document.getSelection()
            var range=selection.getRangeAt(0)
            var start=""
            var end=""
            start=toP(range.startContainer)
            end=toP(range.endContainer)
            startToEnd(start,end)
            // undoAandRundo()
        }
    }

    function addp(text)
    {console.log(222)
        var childNode=text.childNodes
        var sel=document.getSelection()
        var r=document.createRange()
        var leng=childNode.length
        for(var i=0;i<leng;i++)
        {
            if(childNode[i] instanceof Text)
            {
                var p=document.createElement("p")
                p.innerHTML=childNode[i].nodeValue
                childNode[i].parentNode.insertBefore(p,childNode[i])
                childNode[i].parentNode.removeChild(childNode[i+1])
                r.selectNodeContents(p)
                sel.addRange(r)
            }
        }
    }

    function startToEnd(start,end)
    {

        console.log(666)
        var next=start
        var end=end
        var flag=0
        while(true)
        {
            console.log( "startToEnd(start,end)")
            if(next.length!=0&&next!=null&&next!=end)
            {
                add(next)
                next=toP(next.nextElementSibling)
            }
            else if(next==end)
            {
                add(next)
                break
            }
            else
            {
                break
            }
        }
    }

    function toP(el)
    {
        console.log(1010)
        var el=el
        var container=""
        while(true)
        {
            // if(el.tagName!="P"&&el.className!="#PContainer#")
            console.log("toP(el)")
            if(el.tagName!="P")
            {
                el=el.parentNode
                container=el.getElementsByClassName("#divContainer#")
                if(container.length!=0)
                {
                    console.log("addDiagonal()中出容器超过或等于编辑框")
                    el=false
                    break
                }
            }
            else
            {
                break
            }
        }
        return el
    }

    function add(el)
    {
        console.log(7575)
        if(el==false)
        {
            return ""
        }
        var sp=el.innerHTML.split("&nbsp;")
        var str=""
        var flag=0
        for(var i=0;i<sp.length;i++)
        {
            if(sp[i].replace(/\s+/ig,"").length<1)
            {
                str+="&nbsp;"
            }
            else if(flag==0)
            {
                if(/^\/\//.test(sp[i].replace(/^\s+/ig,"")))
                {
                    sp[i]=sp[i].replace(/^\s+/ig,"").replace(/^\/\//,"")
                }
                else
                {
                    str+="//"
                }
                flag=1
            }
            if(flag==1)
            {
                str+=sp[i]
            }
        }
        el.innerHTML=str
        var r=document.createRange()
        r.selectNodeContents(el)
        r.collapse(false)
        var sel=document.getSelection()
        sel.removeAllRanges()
        sel.addRange(r)
    }
}

//工具条根据鼠标动
function  toolMove()
{
    var m=document.getElementById("iconBox")
    var start=0
    var end=0
    var x=0
    var y=0

    m.addEventListener("mousedown",function(e)
    {
        if(m.style.position=="fixed")
        {
            start=e.pageX
            end=e.pageY
            m.addEventListener('mousemove', mouseMove)

            document.addEventListener("mouseup",function()
            {
                m.removeEventListener('mousemove', mouseMove);
            }
            )
        }
    }
    )

    function mouseMove(event)
    {
        x=event.pageX-start
        y=event.pageY-end
        start=event.pageX
        end=event.pageY
        var left=m.style.left.replace("px","")
        var top=m.style.top.replace("px","")
        if(left.length==0)
        {
            left=0
        }
        else
        {
            left=parseInt(left)
        }
        if(top.length==0)
        {
            top=0
        }
        else
        {
            top=parseInt(top)
        }
        m.style.left=left+x+"px"
        m.style.top=top+y+"px"
    }
}

// table空格键
function table()
{

    document.addEventListener("keydown",function(e)
    {
        if(e.key=="Tab")
        {
            e.preventDefault()
            sel = document.getSelection();
            if (sel.getRangeAt && sel.rangeCount)
            {
                var range = sel.getRangeAt(0);
                range.deleteContents();
                var  textNode = document.createTextNode('\u00A0\u00A0\u00A0\u00A0');
                range.insertNode(textNode);
                range.setStart(textNode, 4);
                range.setEnd(textNode, 4);
                sel.removeAllRanges();
                sel.addRange(range);
            }
        }
    }
    )
}

// 解决表格张贴会带格式的问题
function  paseText()
{
    var td=document.getElementsByTagName("td")
    for(var i=0;i<td.length;i++)
    {

        td[i].addEventListener('paste', function(e)
        {
            e.preventDefault();  // 阻止默认粘贴行为
            var txt = '';
            if (e.clipboardData || window.clipboardData)
            {
                txt = (e.clipboardData || window.clipboardData).getData('text/plain');
            }
            if (document.queryCommandSupported('insertText'))
            {
                document.execCommand('insertText', false, txt);
            }
            else
            {
                // 对于不支持 insertText 的浏览器
                this.value += txt;
            }
        }
        )
    }
}

//解决在编辑框中点击表格的问题**和下面的一起用
function tdclick()
{
    var td=document.getElementsByTagName("td")
    for(var i=0;i<td.length;i++)
    {
        (td[i].onclick=showHW)(i)
    }
}

//解决方向键问题
function  editeTable()
{
    var position=0
    var tp=0

    // 鼠标按钮
    document.addEventListener("keydown",function(e)
    {
        //恢复原来的值
        function restore(x,im)
        {
            td[x].innerHTML=im.value
        }

        var data=getdata()
        if(data==null||data==undefined||Object.keys(data)[0]=="text"||Object.keys(data).length==0||!data[Object.keys(data)[0]].includes("td"))
        {
            return
        }
        var id=data[Object.keys(data)[0]].split("td")[0].trim()
        var table=document.getElementById(id)
        if(table==null||table==undefined)
        {
            return
        }
        var tr=table.getElementsByTagName("tr")
        var td=table.getElementsByTagName('td');
        var trC=tr.length
        var tdC=tr[0].getElementsByTagName("td").length
        var inp=document.createElement("input")
        position=(parseInt(Object.keys(data)[0].split("tr")[1].trim())-1)*tdC+parseInt(Object.values(data)[0].split("td")[1].trim())-1
        table.click()
        inp.type="text"
        inp.style.width="100%"
        inp.style.height=td[tp].style.height

        inp.addEventListener('blur', function()
        {
            restore(tp,inp)
        }
        )
        if(e.code=="ArrowDown")
        {
            e.preventDefault()
            if((position+tdC)<(tdC*trC))
            {
                position+=tdC
                inp.value=td[position].innerText
                td[position].innerHTML=""
                td[position].appendChild(inp)
                inp.focus()
                tp=position
            }
        }
        if(e.code=="ArrowRight")
        {
            e.preventDefault()
            if(position<(tdC*trC)-1)
            {
                position+=1
                inp.value=td[position].innerText
                td[position].innerHTML=" "
                td[position].appendChild(inp)
                inp.focus()
                tp=position
            }
        }
        if(e.code=="ArrowLeft")
        {
            e.preventDefault()
            if(position>0)
            {
                position-=1
                inp.value=td[position].innerText
                td[position].innerHTML=" "
                td[position].appendChild(inp)
                inp.focus()
                tp=position
            }
        }
        if(e.code=="ArrowUp")
        {
            e.preventDefault()
            if((position-trC)>=0)
            {
                position-=tdC
                inp.value=td[position].innerText
                td[position].innerHTML=" "
                td[position].appendChild(inp)
                //由于要先聚焦到另一个元素，才能导致失焦
                //而选择另一个元素必须要显示并聚焦
                //所以造成postion修改了，之后显示并移焦
                //并调动失焦函数，而这是position已经改变
                //所以要先使用原来的position，再改变
                //****这里是造成失焦的方法
                inp.focus()
                tp=position
            }
        }
    }
    )
}

//拖拉文件直接到编辑框进行上传
function dragImage()
{
    var text=document.getElementById("text")
    text.addEventListener('dragover', (e) =>
    {
        e.preventDefault()
        e.stopPropagation()
    }
    )
    text.addEventListener('drop',(e) =>
    {
        e.preventDefault()
        e.stopPropagation()
        var file=e.dataTransfer.files[0]
        if(file==null||file==undefined)
        {
            return
        }
        var cls=document.getElementById("cls")
        var sp=text.innerText.split("\n")
        var fileName=file.name
        var uploadUrl="dealCenter.php"
        var getTitle=""
        var cL=cls.value
        for(var i=0;i<sp.length;i++)
        {
            if(sp[i].replace(/\s+/ig,"").length!=0)
            {
                getTitle=sp[i].replace(/\s+/ig,"")
                break
            }
        }
        if(getTitle=="")
        {
            alert("请输入标题")
            return
        }
        else if(cL.length==0)
        {
            alert("请输入分类")
            return
        }
        text.focus()
        state("开始上传....")
        fileName=getDate()+"-"+cL+"-"+getTitle+"-"+fileName
        var formData= new FormData();
        formData.append("file", file);
        formData.append("cls",cL)
        formData.append("fc","uploadImg")
        formData.append("fileName",fileName)
        formData.append("dataFlag",cL+"#-#"+getTitle)
        formData.append("subEd",subEd.value)
        formData.append("oDataFlag",oDataFlag.value)
        getFileSize=file.size/1048576
        if(getFileSize>setSize)
        {
            alert("js:文件超过设定大小，请在服务器修改")
            return ;
        }

        setTimeout(function()
        {

            ajax(formData,uploadUrl,"0",function(e)
            {
                if(e=="ok")
                {
                    var ele=showlink("/static/media/"+fileName,fileName)
                    if(ele!="")
                    {
                        var count=0
                        var flag=document.getElementById('#flag#')
                        //解决误插入多个标记的问题
                        if(flag!=undefined||flag!=null)
                        {
                            flag.parentElement.removeChild(flag)
                        }
                        var saveData=document.getElementById('saveData')
                        var p=document.createElement('p')
                        var selection=document.getSelection()
                        var range=selection.getRangeAt(0)
                        var frg = range.createContextualFragment("<p id='#flag#'></p>");
                        range.insertNode(frg);
                        flag=document.getElementById('#flag#')
                        setTimeout(function()
                        {
                            while(flag==null)
                            {
                                console.log("dragImage()")
                                flag=document.getElementById('#flag#')
                                count+=1
                                if(count>500&&flag!=null&&flag!=undefined)
                                {
                                    alert("dragImage()中出现问题")
                                    return
                                }
                            }
                            var startOffset = range.startOffset;
                            var parent=flag.parentElement
                            p.appendChild(ele)
                            parent.innerHTML=p.innerHTML
                            p.innerHTML="<br>"
                            parent.parentElement.insertBefore(p,parent.nextSibling)
                            // 移动光标位置
                            range.setStart(p, startOffset + 1);
                            range.setEnd(p, startOffset + 1);
                            selection.removeAllRanges();
                            selection.addRange(range);
                            //下面的保存按钮不能点，
                            // 避免误删文件导致文件不能通过回退或刷新进行找回
                            // saveData.click()
                            // state("保存成功","yes")
                        }
                        ,1000)
                    }
                }
            }
            ,fileName)
        }
        ,1000)
    }
    )
}

//产生对应的文件元素
function showlink(url,name)
{
    var result=""
    var flag=""
    var sp=name.split(".")
    var stateWorder=document.getElementById("stateWorder")
    var showStates=document.getElementById("showStates")
    for(var i=sp.length-1;i>0;i--)
    {
        if(sp[i].replace(/\s+/ig,"").length!=0)
        {
            flag=sp[i].replace(/\s+/ig,"")
        }
    }
    if(flag=="")
    {
        alert("请选择有类型的文件")
        return
    }
    if(flag=="jpg"||flag=="jpeg"||flag=="webp"||flag=="gif"||flag=="png")
    {
        result=document.createElement('img');
        result.src=url
        result.style.width="60%";
    }
    else if(flag=="mp4")
    {
        result=document.createElement('video');
        result.src=url
        result.contr0ls="controls"
        result.style.width="60%";
    }
    else if(flag=="mp3")
    {
        result=document.createElement('audio');
        result.src=url
        result.style.width="60%";
        result.contr0ls="controls"
    }
    else
    {
        result=document.createElement('a');
        result.href=url
        result.innerText=name
        result.style.width="60%";
    }
    if(result!=""&&result.tagName=="IMG")
    {
        showStates.style.display="block"
        showStates.innerText="进行加载...."

        result.onload=function()
        {
            stateWorder.innerText="状态:加载完成"
            showStates.innerText="进行加载完成"

            setTimeout(function()
            {
                var saveData=document.getElementById('saveData')
                saveData.click()
                stateWorder.innerText="状态:"
                showStates.style.display="none"
            }
            ,2000)
        }
    }
    if(result!="")
    {
        result.setAttribute("class","#-media")
        result.style="display: block; margin: 0px auto; border: 1px solid rgb(204, 204, 204); padding: 10px;width:60%;"
    }
    return result
}
